{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes:\n",
    " * same as 14, but with fixed counting of n_points and n_folds; slightly improved sample segments view"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/mnt/tess/astronet/checkpoints/extended_25_run_17/1/AstroCNNModel_extended_20210321_154527',\n",
       " '/mnt/tess/astronet/checkpoints/extended_25_run_17/2/AstroCNNModel_extended_20210321_161606',\n",
       " '/mnt/tess/astronet/checkpoints/extended_25_run_17/3/AstroCNNModel_extended_20210321_164646',\n",
       " '/mnt/tess/astronet/checkpoints/extended_25_run_17/4/AstroCNNModel_extended_20210321_171723',\n",
       " '/mnt/tess/astronet/checkpoints/extended_25_run_17/5/AstroCNNModel_extended_20210321_174729',\n",
       " '/mnt/tess/astronet/checkpoints/extended_25_run_17/6/AstroCNNModel_extended_20210321_181710',\n",
       " '/mnt/tess/astronet/checkpoints/extended_25_run_17/7/AstroCNNModel_extended_20210321_184652',\n",
       " '/mnt/tess/astronet/checkpoints/extended_25_run_17/8/AstroCNNModel_extended_20210321_191655',\n",
       " '/mnt/tess/astronet/checkpoints/extended_25_run_17/9/AstroCNNModel_extended_20210321_194703',\n",
       " '/mnt/tess/astronet/checkpoints/extended_25_run_17/10/AstroCNNModel_extended_20210321_201726']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "chkpt_root = '/mnt/tess/astronet/checkpoints/extended_25_run_17'\n",
    "data_files = '/mnt/tess/astronet/tfrecords-25-val/*'\n",
    "tces_file = '/mnt/tess/astronet/tces-v6-val.csv'\n",
    "\n",
    "nruns = 10\n",
    "\n",
    "def load_ensemble(chkpt_root, nruns):\n",
    "    checkpts = []\n",
    "    for i in range(nruns):\n",
    "        parent = os.path.join(chkpt_root, str(i + 1))\n",
    "        if not os.path.exists(parent):\n",
    "            break\n",
    "        all_dirs = os.listdir(parent)\n",
    "        if not all_dirs:\n",
    "            break\n",
    "        d, = all_dirs\n",
    "        checkpts.append(os.path.join(parent, d))\n",
    "    return checkpts\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running model 1\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 2\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 3\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 4\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 5\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 6\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 7\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 8\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 9\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 10\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n"
     ]
    }
   ],
   "source": [
    "import getpass\n",
    "import os\n",
    "from astronet import predict\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "def run_predictions(path):\n",
    "    predict.FLAGS = predict.parser.parse_args([\n",
    "      '--model_dir', path,\n",
    "      '--data_files', data_files,\n",
    "      '--output_file', '',\n",
    "    ])\n",
    "\n",
    "    return predict.predict()\n",
    "\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "ensemble_preds = []\n",
    "config = None\n",
    "for i, path in enumerate(paths):\n",
    "    print(f'Running model {i + 1}')\n",
    "    preds, config = run_predictions(path)\n",
    "    ensemble_preds.append(preds.set_index('tic_id'))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = ['disp_E', 'disp_N', 'disp_J', 'disp_S', 'disp_B']\n",
    "\n",
    "col_e = labels.index('disp_E')\n",
    "thresh = config.hparams.prediction_threshold\n",
    "# thresh = 0.95"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "agg_preds = {}\n",
    "\n",
    "for preds in ensemble_preds:\n",
    "    for tic_id in preds.index:\n",
    "        if tic_id not in agg_preds:\n",
    "            agg_preds[tic_id] = []\n",
    "\n",
    "        row = preds[preds.index == tic_id]\n",
    "        pred_v = row.values[0]\n",
    "        if len(row.values) > 1:\n",
    "            print(f'Warning: duplicate predictions for {tic_id}')\n",
    "        if pred_v[col_e] >= thresh:\n",
    "            agg_preds[tic_id].append('disp_E')\n",
    "        else:\n",
    "            masked_v = [v if i != col_e else 0 for i, v in enumerate(pred_v)]\n",
    "            agg_preds[tic_id].append(preds.columns[np.argmax(masked_v)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_preds = []\n",
    "for tic_id in list(agg_preds.keys()):\n",
    "    counts = {l: 0 for l in labels}\n",
    "    for e in agg_preds[tic_id]:\n",
    "        counts[e] += 1\n",
    "    maxcount = max(counts.values())\n",
    "    counts.update({\n",
    "        'tic_id': tic_id,\n",
    "        'maxcount': maxcount,\n",
    "    })\n",
    "    final_preds.append(counts)\n",
    "    \n",
    "final_preds = pd.DataFrame(final_preds).set_index('tic_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "tce_table = pd.read_csv(tces_file, header=0).set_index('tic_id')\n",
    "tce_labels = tce_table[labels]\n",
    "\n",
    "pl = final_preds.join(tce_labels, on='tic_id', how='left', lsuffix='_p')\n",
    "\n",
    "pl.head()\n",
    "pd.set_option('display.max_columns', None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recall: 0.9869565217391304\n",
      "Precision: 0.7491749174917491\n"
     ]
    }
   ],
   "source": [
    "ppos = (pl['disp_E_p'] > 0)\n",
    "pos = (pl['disp_E'] > 0)\n",
    "\n",
    "pneg = (pl['disp_E_p'] == 0)\n",
    "neg = (pl['disp_E'] == 0)\n",
    "\n",
    "print('Recall:', len(pl[ppos & pos]) / len(pl[pos]))\n",
    "print('Precision:', len(pl[ppos & pos]) / len(pl[ppos]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "141753278\n",
      "158159741\n",
      "404220255\n"
     ]
    }
   ],
   "source": [
    "for i in pl[pos & pneg][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "113496703\n",
      "118398402\n",
      "183076970\n",
      "201601338\n",
      "276738707\n",
      "277045346\n",
      "277941517\n",
      "278632192\n",
      "281578420\n",
      "291374558\n",
      "293527927\n",
      "300153494\n",
      "302968162\n",
      "30407196\n",
      "309650507\n",
      "311103813\n",
      "319865847\n",
      "320356995\n",
      "326693475\n",
      "363404187\n",
      "373919592\n",
      "379191982\n",
      "379356723\n",
      "384341508\n",
      "38679633\n",
      "404851508\n",
      "404851552\n",
      "404851966\n",
      "404934011\n",
      "40602499\n",
      "406971913\n",
      "407615704\n",
      "410087746\n",
      "446698252\n",
      "466098383\n",
      "283330382\n",
      "375927073\n",
      "14209654\n",
      "188258751\n",
      "199376584\n",
      "267924099\n",
      "136651206\n",
      "154214348\n",
      "395164445\n",
      "417208086\n",
      "252588526\n",
      "409455240\n",
      "431338538\n",
      "192591652\n",
      "198555242\n",
      "279064110\n",
      "301829477\n",
      "468608862\n",
      "127846210\n",
      "21133246\n",
      "261814771\n",
      "269291226\n",
      "308805406\n",
      "408945155\n",
      "648359612\n",
      "82242456\n",
      "142751024\n",
      "56861756\n",
      "138847344\n",
      "97487520\n",
      "154271808\n",
      "159636125\n",
      "230197530\n",
      "284266496\n",
      "298647682\n",
      "123489614\n",
      "164528404\n",
      "165500081\n",
      "237278147\n",
      "27896467\n",
      "405687343\n"
     ]
    }
   ],
   "source": [
    "for i in pl[neg & ppos][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'ensemble_preds' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-4abd97b2b72b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mcompare\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mensemble_preds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpreds\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m312471474\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'ensemble_preds' is not defined"
     ]
    }
   ],
   "source": [
    "def compare(ensemble_preds, filter):\n",
    "    result = ensemble_preds[0][filter]\n",
    "    for preds in ensemble_preds[1:]:\n",
    "        result = result.append(preds[filter])\n",
    "    return result\n",
    "\n",
    "compare(ensemble_preds, preds.index == 405687343)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_E_p</th>\n",
       "      <th>disp_N_p</th>\n",
       "      <th>disp_J_p</th>\n",
       "      <th>disp_S_p</th>\n",
       "      <th>disp_B_p</th>\n",
       "      <th>maxcount</th>\n",
       "      <th>disp_E</th>\n",
       "      <th>disp_N</th>\n",
       "      <th>disp_J</th>\n",
       "      <th>disp_S</th>\n",
       "      <th>disp_B</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_E_p, disp_N_p, disp_J_p, disp_S_p, disp_B_p, maxcount, disp_E, disp_N, disp_J, disp_S, disp_B]\n",
       "Index: []"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl[pl.index == 421845505]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PR curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "tics = set(ensemble_preds[0].index.values)\n",
    "\n",
    "tic_index = {v: i for i, v in enumerate(tics)}\n",
    "\n",
    "pred_es = np.zeros([len(ensemble_preds), len(tic_index)])\n",
    "for i, preds in enumerate(ensemble_preds):\n",
    "    for row in preds.iterrows():\n",
    "        tic, pred_e = row[0], row[1][col_e]\n",
    "        pred_es[i][tic_index[tic]] = pred_e\n",
    "\n",
    "lbl_es = np.zeros([len(tic_index)], dtype=np.bool)\n",
    "for row in tce_labels.iterrows():\n",
    "    tic, lbl_e = row[0], row[1]['disp_E']\n",
    "    if tic in tic_index:\n",
    "        lbl_es[tic_index[tic]] = (lbl_e > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cond_pos = float(np.sum(lbl_es))\n",
    "\n",
    "def pr_at_th(th):\n",
    "    pred_pos = np.any(pred_es >= th, axis=0)\n",
    "    true_pos = pred_pos & lbl_es\n",
    "    num_pred_pos = int(np.sum(pred_pos))\n",
    "    num_true_pos = int(np.sum(true_pos))\n",
    "    if num_pred_pos == 0:\n",
    "        return 1.0, 0.0\n",
    "    return float(num_true_pos) / float(num_pred_pos), float(num_true_pos) / float(num_cond_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUC: 0.977660698925515, max R: 1.0, max P: 1.0\n",
      "100% recall at: 48%, threshold: 0.01949672174459194\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x740 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "ps, rs, ths = ([], [], [])\n",
    "th = np.max(pred_es)\n",
    "while th >= 0.0:\n",
    "    p, r = pr_at_th(th)\n",
    "    if p > 0:\n",
    "        ps.append(p)\n",
    "        rs.append(r)\n",
    "    else:\n",
    "        ps.append(1.0)\n",
    "        rs.append(0.0)\n",
    "    ths.append(th)\n",
    "    th -= 0.0005\n",
    "    \n",
    "from sklearn import metrics\n",
    "\n",
    "print(f'AUC: {metrics.auc(rs, ps)}, max R: {max(rs)}, max P: {max(ps)}')\n",
    "    \n",
    "i = len(rs) - 1\n",
    "while rs[i] == 1.0:\n",
    "    i -= 1\n",
    "i += 1\n",
    "print(f'100% recall at: {int(ps[i] * 100)}%, threshold: {ths[i]}')\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 3.7), dpi=200)\n",
    "\n",
    "ax.spines['top'].set_color('#808080')\n",
    "ax.spines['right'].set_color('#808080')\n",
    "ax.spines['left'].set_color('#808080')\n",
    "ax.spines['bottom'].set_color('#808080')\n",
    "ax.tick_params(direction='in', color='#808080')\n",
    "\n",
    "plt.grid(color='#c0c0c0', linestyle='--', linewidth=0.5)\n",
    "\n",
    "plt.ylabel('Precision', fontweight='bold')\n",
    "plt.xlabel('Recall', fontweight='bold')\n",
    "\n",
    "plt.xlim((0.4, 1.0))\n",
    "plt.ylim((0.4, 1.0))\n",
    "\n",
    "_ = plt.plot(rs, ps)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
